Primo Passo nel Quantum Computing

Difficoltà: Principiante
Utilizzo del tempo QPU: 11s

Benvenuto, hacker! Siamo felici di averti al workshop. L'obiettivo principale di questo hands-on introduttivo è prepararti per il tuo viaggio nel quantum computing con 1) una guida su come installare qiskit 2) come creare un account IBM Cloud e preparare api_key e crn per usare un vero computer quantistico e 3) creare il tuo primo Circuit quantistico, 4) risolvere un quiz sugli stati quantistici e 5) eseguire i tuoi Circuit su un vero computer quantistico e visualizzare i risultati.

1. Prima di tutto: Qiskit

Cos'è Qiskit

Il Qiskit SDK è uno stack software ad alte prestazioni progettato per aiutare sviluppatori e ricercatori a sfruttare appieno la potenza dei computer quantistici su scala di utilità e oltre. Al suo nucleo c'è il Qiskit SDK, un kit di sviluppo software open source per lavorare con i computer quantistici a livello di Circuit quantistici estesi, operatori e primitivi. Il Qiskit SDK permette a chiunque di ottenere prestazioni ottimali dai computer quantistici reali utilizzando il proprio ambiente di calcolo preferito.

Oltre all'SDK, Qiskit include anche una suite di strumenti e servizi ad alte prestazioni come il Qiskit Runtime Service, che consente calcoli ottimizzati sui computer quantistici IBM tramite il cloud usando primitivi che gestiscono la mitigazione degli errori. Il Qiskit Transpiler service, che fornisce metodi euristici e basati sull'intelligenza artificiale all'avanguardia per migliorare le prestazioni nelle comuni attività di ottimizzazione dei Circuit quantistici.

Qiskit functions, un catalogo di servizi IBM e di terze parti che semplificano l'ottimizzazione dei carichi di lavoro e l'utilizzo di Qiskit per casi d'uso industriali. Che tu sia uno sviluppatore di software quantistico, uno sperimentatore nel campo quantistico, uno scienziato computazionale, o semplicemente alle prime armi, il framework modulare e flessibile di Qiskit ti permette di lavorare al livello di astrazione più adatto alle tue esigenze.

Qiskit è progettato per essere estensibile e personalizzabile, così puoi ottenere prestazioni all'avanguardia nel settore e affrontare nuovi tipi di problemi. Una base di codice ad alte prestazioni significa che il Qiskit SDK funziona più velocemente, utilizza meno memoria e fornisce risultati migliori che mai. Qiskit ti introduce anche a una vasta comunità di utenti e sviluppatori pronti ad accoglierti e aiutarti a rispondere alle tue domande. Lanciato per la prima volta nel 2019, il programma Qiskit advocate è un'iniziativa globale incentrata sulla comunità che recluta professionisti e appassionati di quantum computing da tutto il mondo. Nel corso degli anni, gli advocate sono diventati leader riconosciuti nella comunità quantistica. Vuoi essere il prossimo leader quantistico? Non esitare a candidarti - qui

Installare Qiskit

Prima di tutto, verifica che la versione di Python utilizzata nel tuo ambiente sia python>=3.10, per assicurarti che sia compatibile con l'ultima versione di Qiskit che useremo

from platform import python_version

print(python_version())

Se non è così, puoi aggiornarlo usando il tuo strumento preferito. Se non sai come farlo, alcune opzioni consigliate sono:

MacOS: Homebrew
Linux: sudo apt-get update

Una guida dettagliata su come aggiornare Python in base al tuo sistema operativo è disponibile qui: How to update Python

Per ulteriori informazioni, dai un'occhiata al wiki QGSS(Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Puoi verificare la tua installazione eseguendo la cella qui sotto. Se l'installazione è corretta, restituirà la versione di qiskit.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Risoluzione dei problemi

Se la cella precedente ha generato un errore, puoi scegliere di installare Qiskit in un ambiente virtuale (di seguito vengono proposti due metodi suggeriti). Se non hai errori, puoi ignorare questa cella e procedere alla successiva.

Qui proponiamo due metodi diversi per configurare un ambiente virtuale in cui installare Qiskit.

Usando venv, come spiegato nella guida all'installazione di Qiskit.
Usando conda, come spiegato in questo video di Coding with Qiskit.

2. Configura il tuo account IBM Cloud

Per usare un vero computer quantistico, hai bisogno di una api key - il biglietto d'ingresso principale al cloud - e di un crn - il token che ti darà accesso alle tue risorse configurando il tuo account.

Configura il tuo account come segue:

Vai alla IBM Quantum® Platform.
Vai nell'angolo in alto a destra (come mostrato nell'immagine sopra), crea il tuo token API e copialo in un luogo sicuro.
Nella cella successiva, sostituisci deleteThisAndPasteYourAPIKeyHere con la tua chiave API.
Vai nell'angolo in basso a sinistra (come mostrato nell'immagine sopra) e crea la tua istanza. Assicurati di scegliere il piano aperto.
Dopo aver creato l'istanza, copia il relativo codice CRN. Potrebbe essere necessario aggiornare la pagina per vedere l'istanza.
Nella cella qui sotto, sostituisci deleteThisAndPasteYourCRNHere con il tuo codice CRN.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

Consulta questa guida per ulteriori dettagli su come configurare il tuo account IBM Cloud®.

⚠️ Nota: Tratta la tua chiave API come faresti con una password sicura. Consulta la guida Cloud setup per ulteriori informazioni sull'utilizzo della tua chiave API in ambienti sicuri e non affidabili.

Inoltre, se sei membro della rete universitaria dei partner IBM, utilizza l'indirizzo email della tua istituzione come IBM ID per ricevere il beneficio partner.

3. Il tuo primo Circuit quantistico

Circuit quantistici

L'unità fondamentale di Qiskit è il Circuit quantistico (quantum circuit), che è una serie di istruzioni che un computer quantistico può usare per lavorare con i bit quantistici di informazione, noti anche come Qubit. Questi Qubit hanno proprietà speciali che consentono ai computer quantistici di affrontare i problemi in modo diverso rispetto al tuo laptop o iPhone. Qiskit sta avanzando rapidamente come tecnologia -- sebbene tu possa ancora progettare manualmente i tuoi Circuit quantistici e decidere come vuoi eseguirli (e ci sono molte buone ragioni per farlo), IBM Quantum ti mette a disposizione anche strumenti che semplificano il processo. Ai fini dell'apprendimento, progetteremo un Circuit molto semplice e lo eseguiremo su un simulatore.

Stiamo scorrendo velocemente questa panoramica perché, onestamente, potremmo passare ore solo a spiegare le basi dell'informazione e del calcolo quantistico. In realtà, IBM Quantum lo ha già fatto, producendo un corso scritto e una serie di lezioni video dedicati all'argomento. Se hai bisogno di un ripasso, dai un'occhiata!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Operazioni di base sui Qubit e Misurazioni

Descrivere gli stati a singolo Qubit

Iniziamo esaminando un singolo Qubit. La differenza principale rispetto a un bit classico, che può assumere solo i valori 0 e 1, è che un bit quantistico, o Qubit, può trovarsi negli stati $\vert0\rangle$ , $\vert1\rangle$ , nonché in una combinazione lineare di questi due stati. Questa caratteristica è nota come sovrapposizione, e ci consente di scrivere lo stato più generale di un Qubit come:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Se misurassimo lo stato di questo Qubit, troveremmo il risultato $1$ con probabilità $p$ , e il risultato $0$ con probabilità $1-p$ . Come puoi vedere, la probabilità totale è $1$ , il che significa che misureremo effettivamente $0$ o $1$ , e non esistono altri risultati possibili.

Oltre a $p$ , potresti aver notato un altro parametro sopra. La variabile $\phi$ indica la fase quantistica relativa tra i due stati $\vert0\rangle$ e $\vert1\rangle$ . Come scopriremo più avanti, questa fase relativa è piuttosto importante. Per ora, è sufficiente notare che la fase quantistica è ciò che consente l'interferenza tra stati quantistici, permettendoci di scrivere algoritmi quantistici per risolvere compiti specifici.

Visualizzare gli stati quantistici

Visualizziamo gli stati quantistici in questo esercizio usando quello che è noto come qsphere. Ecco come appare la qsphere per gli stati $\vert0\rangle$ e $\vert1\rangle$ , rispettivamente. Nota che la parte più alta della sfera rappresenta lo stato $\vert0\rangle$ , mentre la parte inferiore rappresenta $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Puoi ottenere esattamente la stessa QSphere usando un Circuit quantistico. Il vettore di stato qui utilizzato è dallo stato $|0\rangle$ . In Qiskit, il Qubit viene inizializzato nello stato $|0\rangle$ . Prova a eseguire il Circuit qui sotto e guarda se riesci a ottenere la stessa QSphere.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Ora visualizziamo lo stato $|1\rangle$ . Non dovrebbe sorprendere che lo stato di sovrapposizione con fase quantistica $\phi = 0$ e probabilità $p = 1/2$ (che significa uguale probabilità di misurare 0 e 1) venga mostrato sulla qsphere con due punti. Nota tuttavia che la dimensione dei cerchi nei due punti è più piccola rispetto a quando avevamo semplicemente $\vert0\rangle$ e $\vert1\rangle$ sopra. Questo perché la dimensione dei cerchi è proporzionale alla probabilità di misurare ciascuno, che ora è ridotta della metà.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Nel caso degli stati di sovrapposizione, dove la fase quantistica è diversa da zero, la qsphere ci permette di visualizzare quella fase modificando il colore del rispettivo blob. Ad esempio, lo stato con $\phi = 90^\circ$ (gradi) e probabilità $p = 1/2$ è mostrato nella qsphere qui sotto.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Manipolare i Qubit

I Qubit vengono manipolati applicando Gate quantistici. Esaminiamo una panoramica dei diversi Gate che considereremo negli esercizi seguenti.

Prima di tutto, descriviamo come possiamo cambiare il valore di $p$ per il nostro stato quantistico generale. Per farlo, useremo due Gate:

$X$ -gate: Questo Gate scambia tra i due stati $\vert0\rangle$ e $\vert1\rangle$ . Questa operazione è analoga al Gate NOT classico. Di conseguenza, il Gate $X$ è talvolta chiamato bit flip o Gate NOT. Matematicamente, il Gate $X$ cambia $p$ in $1-p$ , quindi in particolare da 0 a 1, e viceversa.
$H$ -gate: Questo Gate ci permette di passare dallo stato $\vert0\rangle$ allo stato $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Questo stato è noto anche come $\vert+\rangle$ . Matematicamente, ciò significa passare da $p=0, \phi=0$ a $p=1/2, \phi=0$ . Poiché lo stato finale del Qubit è una sovrapposizione di $\vert0\rangle$ e $\vert1\rangle$ , il Gate di Hadamard rappresenta una vera operazione quantistica.

Nota che entrambi i Gate hanno cambiato il valore di $p$ , ma non $\phi$ . Per fortuna, è abbastanza facile visualizzare l'azione di questi Gate guardando la figura qui sotto.

Una volta che abbiamo lo stato $\vert+\rangle$ , possiamo cambiare la fase quantistica applicando diversi altri Gate. Ad esempio, un Gate $S$ aggiunge una fase di $90$ gradi a $\phi$ , mentre il Gate $Z$ aggiunge una fase di $180$ gradi a $\phi$ . Per sottrarre una fase di $90$ gradi, possiamo applicare il Gate $S^\dagger$ , che si legge S-dagger, e comunemente scritto come sdg. Infine, c'è un Gate $Y$ che applica una sequenza di Gate $Z$ e $X$ .

Puoi sperimentare con i Gate $X$ , $Y$ , $Z$ , $H$ , $S$ e $S^\dagger$ per familiarizzare con le diverse operazioni e come influenzano lo stato di un Qubit. Per farlo, puoi visitare il Circuit Composer e avviare il nostro widget per i Circuit. Dopo aver visitato il Circuit Composer, scegli un Gate da applicare a un Qubit, quindi scegli il Qubit (nei primi esempi, l'unico Qubit da scegliere è il qubit 0). Osserva come lo stato corrispondente cambia con ogni Gate, così come la descrizione di quello stato. Ti fornirà anche il codice che crea il Circuit quantistico corrispondente in Qiskit.

Se vuoi saperne di più sulla descrizione degli stati quantistici, gli operatori di Pauli e altri Gate a singolo Qubit, consulta Quantum Information del Singolo Sistema del Corso Basics of Quantum Information di John Watrous.

Esercizi: Circuit quantistici con Gate a singolo Qubit

Ecco quattro piccoli esercizi per raggiungere diversi stati sulla qsphere. Puoi risolverli con il Circuit Composer e copiare il codice che ti fornisce nelle rispettive celle per creare i Circuit quantistici, oppure puoi inserire direttamente una combinazione delle seguenti righe di codice nel programma per applicare i diversi Gate:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

Il '(0)' indica che applichiamo questo Gate al Qubit 'q0', che è il primo (e in questo caso unico) Qubit.

Prova a raggiungere lo stato indicato sulla qsphere in ciascuno dei seguenti esercizi.

i) Iniziamo eseguendo un bit flip. L'obiettivo è raggiungere lo stato $\vert1\rangle$ partendo dallo stato $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Adesso, creiamo una sovrapposizione. L'obiettivo è raggiungere lo stato $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Combiniamo i due. L'obiettivo è raggiungere lo stato $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

Riesci a combinare i due compiti precedenti per trovare la soluzione?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Infine, passiamo ai numeri complessi. L'obiettivo è raggiungere lo stato $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quantum Quiz with Multi-Qubit Gates

Ottimo lavoro! Ora che hai compreso i gate a singolo qubit, vediamo i gate che operano su più qubit. Qui ti verrà chiesto di risolvere 4 quiz sugli stati quantistici combinando gate a singolo qubit e gate multi-qubit. I gate di base su due qubit sono:

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Se vuoi saperne di più sui diversi gate multi-qubit e le loro relazioni, visita Quantum Information dei sistemi multipli, del corso Basics of Quantum Information di John.

Nota che per due qubit uno stato generale ha la forma $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , dove $a$ , $b$ , $c$ e $d$ sono numeri complessi i cui valori assoluti al quadrato forniscono la probabilità di misurare il rispettivo stato; ad esempio, $|a|^2$ sarebbe la probabilità di ottenere lo stato '0' su entrambi i qubit. Ciò significa che ora possiamo avere fino a quattro punti sulla qsphere.

We start with the canonical two qubit gate, the controlled-NOT (also CNOT or CX) gate. Here, as with all controlled two qubit gates, one qubit is labelled as the "control", while the other is called the "target". If the control qubit is in state $|0\rangle$ , it applies the identity $I$ gate to the target, i.e., no operation is performed. Instead, if the control qubit is in state $|1\rangle$ , an X-gate is performed on the target qubit. Therefore, with both qubits in one of the two classical states, $|0\rangle$ or $|1\rangle$ , the CNOT gate is limited to classical operations.

This situation changes dramatically when we first apply a Hadamard gate to the control qubit, bringing it into the superposition state $|+\rangle$ . The action of a CNOT gate on this non-classical input can produce highly entangled states between control and target qubits. If the target qubit is initially in the $|0\rangle$ state, the resulting state is denoted by $|\Phi^+\rangle$ , and is one of the so-called Bell states.

i) Costruisci lo stato di Bell $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Per questo stato avremmo probabilità $\frac{1}{2}$ di misurare "00" e probabilità $\frac{1}{2}$ di misurare "11". Quindi, i risultati di entrambi i qubit sono perfettamente correlati.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Poi prova a creare lo stato di qubit perfettamente anti-correlati. Nota il segno meno qui, che indica la fase relativa tra i due stati.

ii) Costruisci lo stato di Bell $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Ti viene fornito il Circuit quantistico descritto nella funzione seguente. Scambia gli stati del primo e del secondo qubit per ottenere questa QSphere.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Scrivi un programma da zero che crei lo stato GHZ (su tre qubit), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Esegui il tuo Circuit e visualizza il risultato misurato con un vero computer quantistico

Ora sappiamo come costruire un Circuit quantistico per manipolare uno statevector di qubit. Ed è arrivato il momento della parte più entusiasmante: eseguirlo e vedere l'output! Qui impareremo il modo moderno ed efficace per eseguire i nostri Circuit usando Qiskit.

Un pattern Qiskit è un framework generale per scomporre problemi specifici di dominio e contestualizzare le capacità richieste in fasi. Questo consente la componibilità senza soluzione di continuità di nuove funzionalità sviluppate dai ricercatori di IBM Quantum (e non solo) e apre la strada a un futuro in cui i compiti di calcolo quantistico vengono eseguiti da una potente infrastruttura di calcolo eterogenea (CPU/GPU/QPU).

I quattro passi di un pattern Qiskit sono i seguenti:

Map il problema in Circuit quantistici e operatori
Optimize per l'hardware di destinazione
Execute sull'hardware di destinazione
Post-process i risultati

Abbiamo appena completato il Step 1: Mapping, costruendo Circuit quantistici per generare lo stato quantistico desiderato. Ora, percorriamo i passi rimanenti per vedere i risultati.

Optimize

Qui imposteremo il backend per eseguire i Circuit — puoi selezionare il QPU least busy tra i tuoi gruppi di QPU accessibili, oppure scegliere semplicemente un simulatore se non hai abbastanza tempo GPU rimanente. Una volta scelto un backend, il pass_manager eseguirà il transpile dei tuoi Circuit nei set di gate nativi del backend scelto e li ottimizzerà per ottenere un risultato migliore. Puoi dichiarare facilmente il pass_manager usando generate_preset_pass_manager e impostando l'optimization_level, dove un numero più alto indica più passaggi di ottimizzazione.

Il passo successivo è emozionante: eseguiremo il Circuit quantistico usando Qiskit Runtime!

Lo faremo utilizzando le due primitive Qiskit:

Sampler campiona il registro di output dall'esecuzione di uno o più Circuit quantistici. Il suo output è il conteggio delle misurazioni per singolo shot.
Estimator calcola il valore atteso di uno o più osservabili rispetto agli stati generati dal Circuit quantistico. Il suo output comprende i valori attesi insieme ai rispettivi errori standard.

Qui useremo Sampler per eseguire i nostri Circuit. La cella di codice seguente mostra come definire prima un Backend e un pass manager per esso. Poi aggiungerà measurement a tutti i Circuit e creerà un array di Circuit quantistici (pub) da passare al Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Execute

Eseguiamo i nostri Circuit. Nel caso in cui ci siano molte code di attesa nel cloud, stampa e salva il job_id per un utilizzo successivo e controlla il job_status. Dopo aver visto lo stato del job cambiare in Done, recupera il risultato del job.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-process

L'ultimo passo è interpretare la visualizzazione per comprendere gli stati quantistici che abbiamo creato. Prima di tracciare diversi grafici, raccogliamo tutti i conteggi da tutti i Circuit. Poi creeremo 4 grafici categorizzando i Circuit.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Gli Stati a Singolo Qubit

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Gli Stati a Un Qubit in Sovrapposizione

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Stati a Due Qubit

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Stati a Tre Qubit

plot_distribution(counts_all[8], legend=['qc9'])

Sfida aggiuntiva

Hai riscontrato del rumore nei risultati sperimentali effettivi del Backend? La rimozione del rumore dei qubit è una delle aree di ricerca attive. Prova le varie opzioni di mitigazione e soppressione degli errori di Qiskit Runtime per vedere come cambia il rumore nei risultati di esecuzione! (Nota) Queste opzioni richiedono più tempo QPU.

Informazioni aggiuntive

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Created by: Sophy Shin

Reviewed by: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. Prima di tutto: Qiskit​

Cos'è Qiskit​

Installare Qiskit​

Risoluzione dei problemi​

2. Configura il tuo account IBM Cloud ​

3. Il tuo primo Circuit quantistico​

Circuit quantistici​

Operazioni di base sui Qubit e Misurazioni​

Descrivere gli stati a singolo Qubit​

Visualizzare gli stati quantistici​

Manipolare i Qubit​

Esercizi: Circuit quantistici con Gate a singolo Qubit​

i) Iniziamo eseguendo un bit flip. L'obiettivo è raggiungere lo stato ∣1⟩\vert1\rangle∣1⟩ partendo dallo stato ∣0⟩\vert0\rangle∣0⟩.​

ii) Adesso, creiamo una sovrapposizione. L'obiettivo è raggiungere lo stato ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Combiniamo i due. L'obiettivo è raggiungere lo stato ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Infine, passiamo ai numeri complessi. L'obiettivo è raggiungere lo stato ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Quantum Quiz with Multi-Qubit Gates​

i) Costruisci lo stato di Bell ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Costruisci lo stato di Bell ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Ti viene fornito il Circuit quantistico descritto nella funzione seguente. Scambia gli stati del primo e del secondo qubit per ottenere questa QSphere.​

iv) Scrivi un programma da zero che crei lo stato GHZ (su tre qubit), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Esegui il tuo Circuit e visualizza il risultato misurato con un vero computer quantistico​

Optimize​

Execute​

Post-process​

Sfida aggiuntiva​

Informazioni aggiuntive​